ALMaSS: PollenNectarDevelopmentData Class Reference

A standard class to manage a range of pollen and nectar development curves based on indexed rates. More...

#include <plants.h>

Public Member Functions
	PollenNectarDevelopmentData (string a_tovinputfile, string a_toleinputfile, Landscape *a_land)

	~PollenNectarDevelopmentData ()

double	toleGetPollen (int a_tole, int a_index)

double	toleGetNectar (int a_tole, int a_index)

double	tovGetPollen (int a_tov, int a_index)

double	tovGetNectar (int a_tov, int a_index)

int	tovGetNPCurveNum (TTypesOfVegetation a_tov)

int	toleGetNPCurveNum (TTypesOfVegetation a_tov)

PollenNectarDevelopmentCurveSet	GetPollenNectarCurvePtr (int a_almassLEref)

PollenNectarDevelopmentCurveSet	tovGetPollenNectarCurvePtr (int a_tov_ref)

Protected Attributes
vector< PollenNectarDevelopmentCurve * >	m_tovPollenCurves

vector< PollenNectarDevelopmentCurve * >	m_tovNectarCurves

vector< PollenNectarDevelopmentCurve * >	m_tolePollenCurves

vector< PollenNectarDevelopmentCurve * >	m_toleNectarCurves

vector< int >	m_tov_pollencurvetable

vector< int >	m_tole_pollencurvetable

Detailed Description

A standard class to manage a range of pollen and nectar development curves based on indexed rates.

Constructor & Destructor Documentation

◆ PollenNectarDevelopmentData()

PollenNectarDevelopmentData::PollenNectarDevelopmentData	(	string	a_tovinputfile,
		string	a_toleinputfile,
		Landscape *	a_land
	)

Reads in the number of pollen and nectar curves. Either we have one pair for each tov or we need a look-up table, but because many have the same curves a look up table was used. This however requires another input file for tov types to pollen/nectar curve number. If not using pollen and nectar then this is waste of space, so there is a cfg to turn it off and set all curves to a zero curve.

There are two sets of data structures - some based on tole types and the rest are crops that can be on a field tole. the methods of input is duplicated as far as possible.

tov
We need to open the input file and read in the tov types that have associated curves. Those not specified are assumed to have no nectar or pollen. Numbers used are those defined in LE_TypeClass::TranslateVegTypes for each tov type. First file entry is the number of defined tov_types, followed by pairs of tov_refnum & pollen curve refnum. The next line has a single number for the number of pollen/nectar curves The next lines are in pairs, pollen curve followed by nectar curve each with 365 entries and preceded by the curve number.

tole
We need to open the input file and read in the tov types that have associated curves. Those not specified are assumed to have no nectar or pollen. Numbers used are those defined in LE_TypeClass::TranslateEleTypes for each tole type. First file entry is the number of defined tole_types, followed by pairs of tole_refnum & pollen curve refnum. The next line has a single number for the number of pollen/nectar curves The next lines are in pairs, pollen curve followed by nectar curve each with 365 entries and preceded by the curve number.

 {
     // This forms an empty entry for no pollen or nectar tov types
     vector<double> empty;
     vector<int> index;
     for (int i = 0; i < 366; i++) {
         empty.push_back(0.0);
         index.push_back(i);
     }
     // make space in the lookup table for all tov types
     m_tov_pollencurvetable.resize(tov_Undefined);
     for (int i = 0; i < int(tov_Undefined); i++) m_tov_pollencurvetable[i] = 0;
     // make space in the lookup table for all tole types
     m_tole_pollencurvetable.resize(tole_Foobar);
     for (int i = 0; i < int(tole_Foobar); i++) m_tole_pollencurvetable[i] = 0;
  
     if (cfg_pollen_nectar_on.value())
     {
         ifstream infile(a_tovinputfile.c_str(), ios::in);
         //check if there is an input file
         if (!infile.is_open()) {
             g_msg->Warn("PollenNectarDevelopmentData::PollenNectarDevelopmentData Cannot open the file", a_toleinputfile.c_str());
             exit(1);
         }
         int no_curves;
         int tov, curvenum;
         infile >> no_curves;
         for (int i = 0; i < no_curves-1; i++)
         {
             infile >> tov >> curvenum;
             // convert from the reference number to tov type
             tov = a_land->TranslateVegTypes(tov);
             // store the reference in the pollen nectar lookup table
             m_tov_pollencurvetable[tov] = curvenum;
         }
         // Now read the curve themselves
         m_tovPollenCurves.resize(no_curves);
         m_tovNectarCurves.resize(no_curves);
         // each curve is composed to two sets of 365 numbers. The first being the index set - always 1-365 so there is no need to read this in, so it is filled in here
         vector<double> slopes(366, 0);
         PollenNectarDevelopmentCurve * p_curve;
         p_curve = new PollenNectarDevelopmentCurve(&index, &empty);
         m_tovPollenCurves[0] = p_curve;
         m_tovNectarCurves[0] = p_curve;
         for (int i = 0; i < no_curves; i++)
         {
             // Read the curve number
             infile >> curvenum; 
             infile >> slopes[365];
             // Read in the pollen data and save
             for (int d = 0; d < 365; d++) infile >> slopes[d];
             p_curve = new PollenNectarDevelopmentCurve(&index, &slopes);
             m_tovPollenCurves[curvenum] = p_curve;
             // Read in the nectar data and save
             infile >> slopes[365];
             for (int d = 0; d < 365; d++) infile >> slopes[d];
             p_curve = new PollenNectarDevelopmentCurve(&index, &slopes);
             m_tovNectarCurves[curvenum] = p_curve;
         }
         infile.close();
         infile.open(a_tovinputfile.c_str(), ios::in);
         //check if there is an input file
         if (!infile.is_open()) {
             g_msg->Warn("PollenNectarDevelopmentData::PollenNectarDevelopmentData Cannot open the file", a_toleinputfile.c_str());
             exit(1);
         }
         infile >> no_curves;
         int tole, tolecurvenum;
         for (int i = 0; i < no_curves-1; i++)
         {
             infile >> tole >> tolecurvenum;
             // convert from the reference number to tov type
             tole = a_land->TranslateVegTypes(tole);
             // store the reference in the pollen nectar lookup table
             m_tole_pollencurvetable[tole] = tolecurvenum;
         }
         // Now read the curve themselves
         m_tolePollenCurves.resize(no_curves);
         m_toleNectarCurves.resize(no_curves);
         p_curve = new PollenNectarDevelopmentCurve(&index, &empty);
         m_tolePollenCurves[0] = p_curve;
         m_toleNectarCurves[0] = p_curve;
         for (int i = 1; i <= no_curves; i++)
         {
             // Read the curve number
             infile >> tolecurvenum;
             // Read in the pollen data and save
             infile >> slopes[366];
             for (int d = 0; d < 365; d++) infile >> slopes[d];
             p_curve = new PollenNectarDevelopmentCurve(&index, &slopes);
             m_tolePollenCurves[tolecurvenum] = p_curve;
             // Read in the nectar data and save
             infile >> slopes[365];
             for (int d = 0; d < 365; d++) infile >> slopes[d];
             p_curve = new PollenNectarDevelopmentCurve(&index, &slopes);
             m_toleNectarCurves[tolecurvenum] = p_curve;
         }
         infile.close();
     }
     else
     {
         PollenNectarDevelopmentCurve*  pnc = new PollenNectarDevelopmentCurve(&index, &empty);
         // Set all to zero curve
         m_tovPollenCurves.push_back(pnc);
         m_tovNectarCurves.push_back(pnc);
         m_tolePollenCurves.push_back(pnc);
         m_toleNectarCurves.push_back(pnc);
         for (int tov = 0; tov<int(tov_Undefined); tov++)
         {
             m_tov_pollencurvetable[tov] = 0;
         }
         for (int tole = 0; tole<int(tole_Foobar); tole++)
         {
             m_tole_pollencurvetable[tole] = 0;
         }
     }
 }

References cfg_pollen_nectar_on, g_msg, m_tole_pollencurvetable, m_toleNectarCurves, m_tolePollenCurves, m_tov_pollencurvetable, m_tovNectarCurves, m_tovPollenCurves, tole_Foobar, tov_Undefined, Landscape::TranslateVegTypes(), CfgBool::value(), and MapErrorMsg::Warn().

◆ ~PollenNectarDevelopmentData()

PollenNectarDevelopmentData::~PollenNectarDevelopmentData ( )

 {
     for (int i = 0; i < m_tovPollenCurves.max_size(); i++) delete m_tovPollenCurves[i];
     for (int i = 0; i < m_tovNectarCurves.max_size(); i++) delete m_tovNectarCurves[i];
     for (int i = 0; i < m_tolePollenCurves.max_size(); i++) delete m_tolePollenCurves[i];
     for (int i = 0; i < m_toleNectarCurves.max_size(); i++) delete m_toleNectarCurves[i];
 }

References m_toleNectarCurves, m_tolePollenCurves, m_tovNectarCurves, and m_tovPollenCurves.

Member Function Documentation

◆ GetPollenNectarCurvePtr()

PollenNectarDevelopmentCurveSet PollenNectarDevelopmentData::GetPollenNectarCurvePtr ( int a_almassLEref )

Uses the almass LE ref num to find the relevant curve set and return it as a pointer. Zero is a special case since this is the empty pollen/nectar curve - it is not an almass LE ref The other special case is rotational crop field, in which case the initialisation is done when the crop is assigned

 {
     PollenNectarDevelopmentCurveSet set;
     set.m_pollencurveptr = m_tolePollenCurves[0];;
     set.m_nectarcurveptr = m_toleNectarCurves[0];;
     if ((a_almassLEref == 0) || (g_letype->TranslateEleTypes(a_almassLEref) == tole_Field) || (g_letype->TranslateEleTypes(a_almassLEref) == tole_UnsprayedFieldMargin)) return set;
     set.m_pollencurveptr = m_tolePollenCurves[m_tole_pollencurvetable[g_letype->TranslateEleTypes(a_almassLEref)]];
     set.m_nectarcurveptr = m_toleNectarCurves[m_tole_pollencurvetable[g_letype->TranslateEleTypes(a_almassLEref)]];
     return set;
 }

References g_letype, PollenNectarDevelopmentCurveSet::m_nectarcurveptr, PollenNectarDevelopmentCurveSet::m_pollencurveptr, m_tole_pollencurvetable, m_toleNectarCurves, m_tolePollenCurves, tole_Field, tole_UnsprayedFieldMargin, and LE_TypeClass::TranslateEleTypes().

Referenced by LE::SetPollenNectarData().

◆ toleGetNectar()

double PollenNectarDevelopmentData::toleGetNectar	(	int	a_tole,
		int	a_index
	)

inline

230 { return m_toleNectarCurves[int(a_tole)]->GetData(a_index); }

◆ toleGetNPCurveNum()

int PollenNectarDevelopmentData::toleGetNPCurveNum ( TTypesOfVegetation a_tov )

inline

234 { return m_tole_pollencurvetable[a_tov]; }

◆ toleGetPollen()

double PollenNectarDevelopmentData::toleGetPollen	(	int	a_tole,
		int	a_index
	)

inline

229 { return m_tolePollenCurves[int(a_tole)]->GetData(a_index); }

◆ tovGetNectar()

double PollenNectarDevelopmentData::tovGetNectar	(	int	a_tov,
		int	a_index
	)

inline

232 { return m_tovNectarCurves[int(a_tov)]->GetData(a_index); }

◆ tovGetNPCurveNum()

int PollenNectarDevelopmentData::tovGetNPCurveNum ( TTypesOfVegetation a_tov )

inline

233 { return m_tov_pollencurvetable[a_tov]; }

◆ tovGetPollen()

double PollenNectarDevelopmentData::tovGetPollen	(	int	a_tov,
		int	a_index
	)

inline

231 { return m_tovPollenCurves[int(a_tov)]->GetData(a_index); }

◆ tovGetPollenNectarCurvePtr()

PollenNectarDevelopmentCurveSet PollenNectarDevelopmentData::tovGetPollenNectarCurvePtr ( int a_tov_ref )

Uses the tov ref num to find the relevant curve set and return it as a pointer.

 {
     PollenNectarDevelopmentCurveSet set;
     set.m_pollencurveptr = m_tolePollenCurves[0];;
     set.m_nectarcurveptr = m_toleNectarCurves[0];;
     set.m_pollencurveptr = m_tovPollenCurves[m_tov_pollencurvetable[ a_tov_ref ]];
     set.m_nectarcurveptr = m_tovNectarCurves[m_tov_pollencurvetable[a_tov_ref]];
     return set;
 }